/*
 Problem Description
大家一定觉的运动以后喝可乐是一件很惬意的事情，但是seeyou却不这么认为。因为每次当seeyou买了可乐以后，
阿牛就要求和seeyou一起分享这一瓶可乐，而且一定要喝的和seeyou一样多。但seeyou的手中只有两个杯子，
它们的容量分别是N 毫升和M 毫升 可乐的体积为S （S<101）毫升　(正好装满一瓶) ，
它们三个之间可以相互倒可乐 (都是没有刻度的，且 S==N+M，101＞S＞0，N＞0，M＞0) 。
聪明的ACMER你们说他们能平分吗？如果能请输出倒可乐的最少的次数，如果不能输出"NO"。
 

Input
三个整数 : S 可乐的体积 , N 和 M是两个杯子的容量，以"0 0 0"结束。
 9

Output
如果能平分的话请输出最少要倒的次数，否则输出"NO"。
 

Sample Input
7 4 3
4 1 3
0 0 0
 

Sample Output
NO
3
 */
package com.yuan.algorithms.acm201506;

import java.util.Scanner;

public class HD1495非常可乐 {

	static int[][][] mark;// 标记数组，用于标记到达某种状态下的次数

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int s = sc.nextInt();// 可乐总量
			int n = sc.nextInt();
			int m = sc.nextInt();
			if (s == 0 && n == 0 && m == 0) {
				break;
			}
			// 奇数无法平分，直接输出结果
			if (s % 2 != 0) {
				System.out.println("NO");
				continue;
			}
			int[] origin = {s, 0, 0, 0};
			mark = new int[s][n][m];
			Queue queue = new Queue();
			queue.add(origin);
			while (!queue.isEmpty()) {
				int[] temp = (int[]) queue.poll();
				mark[temp[0]][temp[1]][temp[2]]= temp[3];
				queue.add(new int[] {temp[0]-(n-temp[1]), });
			}
		}
	}

}


/*
 * 循环数组实现队列
 */
class Queue {
	
	private static final int CAP = 10;// 队列默认大小
	private Object[] elements;// 数据元素数组
	private int capacity;// 数组的大小
	private int front;// 队首指针
	private int rear;// 队尾指针
	
	public Queue() {
		this(CAP);
	}
	
	public Queue(int cap) {
		capacity = cap + 1;// 数组长度加1，用于区分队列满的情况
		elements = new Object[capacity];
		front = rear = 0;
	}
	
	/**
	 * 返回队列大小
	 * 
	 * @return
	 */
	public int getSize() {
		return (rear - front + capacity) % capacity;
	}
	
	/**
	 * 判断队列是否为空
	 * 
	 * @return
	 */
	public boolean isEmpty() {
		return front == rear;
	}
	
	/**
	 * 向队列添加数据
	 * 
	 * @param e
	 */
	public void add(Object e) {
		// 判断队列是否存满了
		if (getSize() == capacity - 1) {
			expandSpace();// 扩展队列
		}
		elements[rear] = e;
		rear = (rear + 1) % capacity;
	}
	
	/**
	 * 扩展队列容量
	 */
	private void expandSpace() {
		Object[] temp = new Object[elements.length * 2 - 1];// 数组容量增大一倍
		int i = front;
		int j = 0;
		// 将从front开始到rear前一个存储单元的元素复制到新数组
		while (i != rear) {
			temp[j++] = elements[i];
			i = (i + 1) % capacity;
		}
		elements = temp;
		capacity = elements.length;
		front = 0;
		rear = j;// 设置新的队尾指针
	}
	
	/**
	 * 队首元素出队
	 * 
	 * @return
	 * @throws Exception
	 */
	public Object poll() throws Exception {
		if (isEmpty()) {
			throw new Exception("错误：队列为空");
		}
		Object obj = elements[front];
		elements[front] = null;// 删除原来的数据
		front = (front + 1) % capacity;// 更新队首指针
		return obj;
	}
	
	/**
	 * 取队首元素（不删除元素）
	 * 
	 * @return
	 * @throws Exception
	 */
	public Object peek() throws Exception {
		if (isEmpty()) {
			throw new Exception("错误：队列为空");
		}
		return elements[front];
	}
}
